Przykad 9.3. Realizacja algorytmu zamiatania prost w Javie
public class LineSeep extends IntersectionDetection {
   // Pamitaj stan zamiatania prost i kolejk zdarze
   LineState lineState = new LineState();
   EventQueue eq = new EventQueue();

   // Oblicz przecicia wszystkich odcinkw z tablicy odcinkw
   public Hashtable<IPoint, ILineSegment[]>
                     intersections (ILineSegment[] segs) {
   // Buduj kolejk zdarze z odcinkw. czc ca odkrywan
   // informacj, zadbaj, aby punkty si nie powtarzay
   for (ILineSegment ils : segs) {
      EventPoint ep = new EventPoint(ils.getStart());
      EventPoint old = eq.event(ep);
      if (old == null) { eq.insert(ep); } else { ep = old; }

      // Dodaj grne odcinki to ep (obiekt w kolejce)
      ep.addUpperLineSegment(ils);

      ep = new EventPoint(ils.getEnd());
      old = eq.event(ep);
      if (old == null) { eq.insert(ep); } else { ep = old; }

      // Dodaj dolne odcinki to ep (obiekt w kolejce)
      ep.addLowerLineSegment(ils);
   }

   // Zamiataj od gry do dou, przetwarzajc kady punkt zdarzenia w kolejce
   while (!eq.isEmpty()) {
      EventPoint p = eq.min();
      handleEventPoint(p);
   }

   // Zwr raport o wszystkich obliczonych przeciciach
   return report;

   // Przetwarzaj zdarzenia, uaktualniajc stan prostej i raportujc przecicia
   private void handleEventPoint (EventPoint ep) {
      // Znajd w stanie prostej odcinki  jeli istniej  na lewo
      // (i na prawo) od ep. Przecicia mog wystpi tylko midzy
      // odcinkami ssiadujcymi. Zacznij od najbliszych, poniewa
      // w trakcie zamiatania prost w d znajdziemy kade nastpne
      // przecicie, ktrym si (na razie) nie zajmujemy.
      AugmentedNode<ILineSegment> left = lineState.leftNeighbor(ep);
      AugmentedNode<ILineSegment> right = lineState.rightNeighbor(ep);

      // Okrel przecicia (ints) ssiadujcych odcinkw i we odcinki
      // grne (ups) i dolne (lows) w tym punkcie zdarze. Przecicie
      // istnieje, jeli z kadym punktem zdarze jest skojarzony
      // wicej ni 1 odcinek
      lineState.determineIntersecting(ep, left, right);
      List<ILineSegment> ints = ep.intersectingSegments();
      List<ILineSegment> ups = ep.upperEndpointSegments();
      List<ILineSegment> lows = ep.lowerEndpointSegments();
      if (lows.size() + ups.size() + ints.size() > 1) {
         record (ep.p, new List[]{lows,ups,ints});
      }

      // Usu wszystko z lewej, a nastpnikiem lewego okae si prawy.
      // Potem uaktualnij punkt zamiatania, dziki czemu przecicia bd
      // uporzdkowane. Wstawiane s tylko odcinki grne i przecicia,
      // poniewa pozostaj one nadal aktywne.
      lineState.deleteRange(left, right);
      lineState.setSweepPoint(ep.p);
      boolean update = false;
      if (!ups.isEmpty()) {
         lineState.insertSegments(ups);
         update = true;
      }
      if (!ints.isEmpty()) {
         lineState.insertSegments(ints);
         update = true;
      }

      // Jeli stan wskazuje na brak przeci w tym punkcie zdarze,
      // to sprawd, czy odcinki lewy i prawy przecinaj si poniej
      // prostej zamiatajcej i odpowiednio uaktualnij kolejk zdarze.
      // W przeciwnym razie, jeli byo przecicie, porzdek odcinkw
      // midzy lewym a prawym zosta zamieniony, tote sprawdzamy
      // dwa konkretne przedziay: lewy i jego (nowy) nastpnik oraz
      // prawy i jego (nowy) poprzednik.
      if (!update) {
         if (left != null && right != null) { updateQueue(left, right); }
      } else {
         if (left != null) { updateQueue(left, lineState.successor(left)); }
         if (right != null) { updateQueue(lineState.pred(right), right); }
      }
   }
   // Dowolne przecicia poniej prostej zamiatajcej s wstawiane jako
   // punkty zdarze
   private void updateQueue (AugmentedNode<ILineSegment> left,
                             AugmentedNode<ILineSegment>  right) {
      // Zbadaj, czy dwa ssiadujce odcinki si przecinaj. Upewnij si,
      // e nowy punkt przecicia jest *poniej* prostej zamiatajcej
      // i nie jest dodawany powtrnie.
      IPoint p = left.key().intersection(right.key());
      if (p == null) { return; }
      if (EventPoint.pointSorter.compare(p,lineState.sweepPt) > 0) {
         EventPoint new_ep = new EventPoint(p);
         if (!eq.contains(new_ep)) { eq.insert(new_ep); }
      }
   }
}
